home *** CD-ROM | disk | FTP | other *** search
/ The PC-SIG Library 9 / The PC-SIG Library on CD ROM - Ninth Edition.iso / 401_500 / DISK0494 / DISK0494.ZIP / TUTORIAL.TXT < prev   
Text File  |  1987-02-12  |  34KB  |  680 lines

  1.  
  2.  
  3.             Programming Suggestions Using
  4.  
  5.             The World Digitized Database
  6.  
  7.  
  8.             Copyright 1986 John B. Allison
  9.  
  10.     
  11.  
  12.  
  13. I.  Simple display program:
  14.     
  15.     1.    Define a world co-ordinate system whose lower  left  corner  is 
  16.     -246  (degrees  West  Long),  -85 (degrees South Lat) and whose 
  17.     upper right corner is 246, 85.
  18.  
  19.     2.    Draw lines of latitude and longitude every 20 degrees  labeling 
  20.      them.
  21.  
  22.     3.    Traverse  a  .mp1  formatted file plotting lines from latitude/ 
  23.      longitude point to point.  Terminate the current  sequence  of 
  24.      connected lines at a blank input record and prepare to start a 
  25.      new sequence if there is one.
  26.  
  27.     4.    The name of the file to be displayed  must  be  accepted  as  a 
  28.      command line argument.
  29.  
  30.     5.    The program should exit after it displays for about 30 seconds.
  31.  
  32. II.  Simple zoom display program:
  33.     Provide  the ability to zoom in on a chosen area of the display 
  34.     in the previous program.
  35.     
  36.     1.    Convert the mainline function of your  Simple  Display  Program 
  37.      (I) to a function named "display1()".
  38.  
  39.     2.    Write   the   function   "zoomwin()"  which  resets  the  world 
  40.      co-ordinates  of  the  display  based  on  input  returned  by 
  41.      "getlocs(x, y)" called from within "zoomwin".
  42.     
  43.     The  aspect  ratio of the world co-ordinates must be maintained 
  44.     even though the requested zoom is not in correct proportion.
  45.  
  46.     One way to signal  program  termination  is  for  "zoomwin"  to 
  47.     return  TRUE  if  a  the zoom was accomplished and FALSE if the 
  48.     same corner is entered twice.  The mainline  alternately  calls 
  49.     "display1" and "zoomwin".
  50.     
  51.     3.    "Getlocs(x,  y)"  returns  the  display  co-ordinates of window 
  52.      corners entered to mark the desired extent of the new display.
  53.     
  54.     Dynamically  mark  the  current  cursor  position   (which   is 
  55.     initially  centered)  by  cross hairs.  Move the cross hairs by 
  56.     the keypad arrow keys (1, 3, 7, and 9 can be used for  diagonal 
  57.     movement).
  58.  
  59.     Cursor  jump  should  be the minimum detectable on your display 
  60.     unless the shift key is  simultaneously  held  down.   Then  it 
  61.     should be 10 times the minimum.
  62.  
  63.     Striking  the  Return  key  should  "mark" a corner of the zoom 
  64.     window with permanent dashed cross hairs.  The user  will  then 
  65.     move  the  solid  cross  hairs to mark the second diametrically 
  66.     opposed corner with a second Return.
  67.  
  68.     The decimal values returned by striking the keypad keys follow:
  69.  
  70.         key    byte1    byte2
  71.  
  72.         1    0    79
  73.         2    0    80
  74.         3    0    81
  75.         4    0    75
  76.         5    0    76
  77.         6    0    77
  78.         7    0    71
  79.         8    0    72
  80.         9    0    73
  81.  
  82. III.  Display Program with Mercator Projection:
  83.     You may have noticed distortion in the maps  displayed  in  the 
  84.     previous   programs,  epecially  at  extreme  latitudes.   This 
  85.     distortion is caused by an attempt to map the curved surface of 
  86.     a three dimensional globe onto a two dimensional plane.  As you 
  87.     travel toward the poles,  the  360  degrees  of  longitude  are 
  88.     squeezed  into less and less space on the globe, but not on the 
  89.     plane.
  90.  
  91.     There are many ways to compensate for the  distortion  problem. 
  92.     Probably  the  solution  most widely recognized is the Mercator 
  93.     projection, named for a famous  early  map  maker.   Mercator's 
  94.     projection  has the characteristics that both lines of latitude 
  95.     and longitude are straight and at right angles  to  each  other 
  96.     (orthogonal).  In addition, if a small area is viewed, there is 
  97.     no distortion of form: areas have the right shape although  the 
  98.     vertical scale and total area is distorted as you move from the 
  99.     equator.
  100.     
  101.     The formula for the Mercator projection is
  102.  
  103.         y = ln{tan[45 deg + latitude/2)/deg_per_radian]}
  104.  
  105.     Check out the Encyclopedia Britannica under Map  for  all  this 
  106.     good stuff and more.
  107.     
  108.     1.    Use  the  Mercator  formula  in a function which, when passed a 
  109.      latitude in degrees, returns a vertical displacement.  Can you 
  110.      predict  what sorts of evil things happen at the poles (90 and 
  111.      -90)?
  112.  
  113.     2.  Use the function "mercator(lat)" to give the  correct  vertical 
  114.      displacement  when generating graphics in Program II.  Set the 
  115.      corners of the world co-ordinates  to  (-246,-2.9)  and  (246, 
  116.      2.9).  The  horizontal  scale  is  still  in degrees while the 
  117.      vertical is in Mercator displacement units.
  118.  
  119. IV.  Faster Display Program:
  120.     What you gained in making your display look more realistic  you 
  121.     paid for in speed.  Real division and tangent and log functions 
  122.     take time, even with a math chip.  The extra time can  be  more 
  123.     than  made  up  for  by  reading  the  pre-calculated  Mercator 
  124.     displacement and longitude  from  a  binary  file  rather  than 
  125.     latitude and longitude from a text file.
  126.     
  127.     1.    Alter  the  input  function of your display program to open and 
  128.      read from a binary .mp2 formatted file  rather  than  from  an 
  129.      ASCII  .mp1  formatted  file.   (Refer  to the section on File 
  130.      Formats for a detailed description.)
  131.  
  132.     2.    Write a program called mp1tomp2 which converts  .mp1  files  to 
  133.      .mp2  files.   This program should accept the name of the file 
  134.      (without extension) as the first command line argument and the 
  135.      destination disk as the second argument.
  136.  
  137.  
  138. V.  Display Program with Print:
  139.     A nice addition to your  display  program  is  the  ability  to 
  140.     reproduce  the displayed image on the printer.  This is an easy 
  141.     addition in some graphics languages.
  142.  
  143.     1.    Add  a  call  to print the displayed image.  The call should be 
  144.      added to function "getloc()" and  activated  by  entering  "p" 
  145.      from  the  keyboard.   Note that upper case "P" (preceded by a 
  146.      null) will result from striking keypad "2".
  147.  
  148.  
  149. Note: If you  are  having  trouble  with  the  Simple  Display  Program 
  150.     outlined  above,  don't  be  discouraged.   The  program is not 
  151.     really simple! When you put enough simple things together, they 
  152.     inevitably  become  complicated  by the nature of their mututal 
  153.     interactions.  That's what structured programming is all about: 
  154.     designing simple and logical interfaces between the many pieces.
  155.     
  156.     If  you  have  simply  come  up  against  a  dead  end or if an 
  157.     alternate solution is desired, the completed source of Programs 
  158.     I  -  V  is available on The World Digitized C Source Disk (see 
  159.     read.me).
  160.  
  161. VI.  Simple Display Program with Scale of Miles:
  162.     As you zoom the display up further and further, you  know  that 
  163.     you  are  getting up closer, but its easy to loose track of the 
  164.     scale, the number of miles from one point to  another,  or  the 
  165.     distance  across  the screen especially with the inherent scale 
  166.     distortion in latitudes greater than 30 degrees.
  167.     
  168.     1.    Add a function which prints an indiction of the scale along the 
  169.      bottom  of  the  display.   This  indication  can  be  a solid 
  170.      horizontal line labeled  with  its  length:  1000  miles,  100 
  171.      miles,   10   miles,  1  mile,  or  whatever  is  appropriate.  
  172.      Alternately the indication could be text showing the width  of 
  173.      the  screen.   In  either case the scale represented should be 
  174.      that scale at the middle of  the  screen.  You  will  need  to 
  175.      define  the  inverse Mercator function "mercainv(y)" to return 
  176.      the latitude when supplied with the vertical offset  from  the 
  177.      equator.
  178.  
  179.     2.    Another  interesting  indicator is the zoom factor which can be 
  180.      placed at either the top or bottom of the display.  Define the 
  181.      initial display zoom ratio as 1.0.  As you zoom in, that ratio 
  182.      increases.   Professional  CAD  (Computer   Aided   Design   & 
  183.      Drafting)  systems  once blew up at factors of about 500.  You 
  184.      will be surprised at how far your display can zoom.  The limit 
  185.      is  ultimately  dependent upon the data representation, single 
  186.      precision real in     the case of Halo.
  187.  
  188.  
  189. VII.  Simple Display Program with Location Display:
  190.     You will want to be able to display the geographic location  of 
  191.     any  point  on  your  display.   The  inverse Mercator function 
  192.     "mercainv()" you constructed for the previous program  will  be 
  193.     useful.
  194.     
  195.     1.    Add the function "markloc()" which, when called by entering the 
  196.      letter "M", displays the cross hairs on the screen.  The cross 
  197.      hairs can be moved with the keypad as in windowing for a zoom, 
  198.      but  when a single Return is entered, a small cross is left to 
  199.      mark the spot.  To the right of the cross (or to the  left  as 
  200.      spacing  permits),  print  the  latitude  and longitude of the 
  201.      location.  This feature is invaluable when  trying  to  relate 
  202.      points on your graphics display to the source .mp1 files.
  203.  
  204.  
  205. VIII.  Simple Display Program with Unzoom:
  206.     Now  that  you can zoom your display anywhere at will, it would 
  207.     be convenient to be able to  change  your  mind,  backup  to  a 
  208.     previous  display,  and  commence again.  The ability to change 
  209.     your mind is available in commerical packages such as Computer- 
  210.     vision's  CADDS  4X graphics system.  In their system a command 
  211.     is never "final" until you hit the Return key.  The results  of 
  212.     your  actions are shown graphically as you enter them, however.  
  213.     If you don't like what you just did, you always have the option 
  214.     of  aborting  the  command  while  it  is still in progress and 
  215.     returning, graphics display as well as data base, back  to  the 
  216.     pre-command state. Pretty nifty!
  217.  
  218.     Without  getting  into  CV's total command interpretor solution 
  219.     which is complicated and arguably ghastly to program, there  is 
  220.     an  interesting  solution  with  two  variations for the lesser 
  221.     problem of returning to previous states from the  current  one.  
  222.     First  of  all  the  states  which  must  be saved are the zoom 
  223.     extents - the world  co-ordinates  for  each  sucessive  zoomed 
  224.     display.   The most straight forward implementation is to store 
  225.     each sucessive display in an array (or a  C  structure).   Each 
  226.     time  the  display is zoomed, the old drawing extents (corners) 
  227.     are stored as the next elements of the array.  To get  back  to 
  228.     any previous zoom ratio, the old extents are retrieved from the 
  229.     array, the last-valid-element-marker  of  the  array  is  moved 
  230.     backward,  and  the drawing is redisplayed.  Care must be taken 
  231.     not to overflow the array.
  232.  
  233.     The more interesting but functionally equivalent approach is to 
  234.     recursively  have  "zoomwin()" call itself thereby storing past 
  235.     extents (and all other variables) on  the  stack.   "Zoomwin()" 
  236.     must  also call "display2()" directly so the drawing can be re- 
  237.     displayed after each zoom.   Recursion  has  the  advantage  of 
  238.     automatically  handling  the  record  keeping chores - no extra 
  239.     arrays  are  necessary.   Recursion  is   also   intellectually 
  240.     challenging.  People don't think that way naturally and its fun 
  241.     to try.  Recursion should  only  be  used  where  it  is  truly 
  242.     advantageous.   Don't  use  it where a simple loop will do.  Be 
  243.     sure that you prepare a  way  of  returning  back  to  yourself 
  244.     otherwise  you  will  recurse yourself right off the end of the 
  245.     stack.
  246.  
  247.     If your stack is too small, the program will fail at  run  time 
  248.     with  a  ***  STACK  OVERFLOW  ***  message  if  you're  lucky. 
  249.     Executing your program
  250.  
  251.             PROGRAM =8000
  252.  
  253.     will allocate an 8000 bytes stack to you program instead of its 
  254.     default  (2048?).  The linker has an optional stack switch good 
  255.     up to 64k, and the Lattice C compiler supports a larger default 
  256.     declaration programmatically.
  257.     
  258.     1.    Add the capability to your program to unzoom.  This can be done 
  259.      by assigning the Esc key the meaning to backup one  level  and 
  260.      redisplay.   For  backing up several levels at once (redisplay 
  261.      takes time), the sequence "-n" where "n"  is  a  single  digit 
  262.      should be used.
  263.  
  264.  
  265. IX.  Simple Display Program which Includes a City/Nation Database:
  266.     The World Digitized comes with no cities.  Making a list of the 
  267.     major  (perhaps  captial)  cities  of  the  world  with   their 
  268.     co-ordinates is a straight forward task.
  269.     
  270.     1.    Make  a  list  of major cities/countries and organize them into 
  271.      file  structure  suitable  for  both  sequencial  and   random 
  272.      processing.   Modify the simple display program so that cities 
  273.      are displayed when a "c" is entered.  The cities are displayed 
  274.      by  a  small filled circle or square.  Choose different shapes 
  275.      or sizes depending on population.  Print the name of the  city 
  276.      beside its shape.
  277.  
  278.     2.    Modify  the  simple  display program to display (at the current 
  279.      zoom factor) a city and its  surroundings  when  an  "f"  (for 
  280.      find)  and its name is entered.  Develop a method for handling 
  281.      ambiguous cases by listing the possible cases and  asking  for 
  282.      additional information such as state or nation.
  283.  
  284.     3.    Modify  the  simple display program to display the names of the 
  285.      nations when an "n" is entered.  If you enter "f" for find and 
  286.      the name of a nation, it should be displayed as in 2 above.
  287.  
  288.  
  289. X.  Program to Display in Polar Co-ordinates:
  290.     If  you  aren't  entirely  sick of map display programs by now, 
  291.     design one to display in polar co-ordinates.  The most suitable 
  292.     continent to display, of course, is Antarctica.  Remember it is 
  293.     in  the  southern  hemisphere,  and  therefore   mathematically 
  294.     backward or inside out.
  295.  
  296.  
  297. XI.  Program to Automatically Clean Up Database:
  298.     As  you  have  already  discovered by this time, there are many 
  299.     small errors in The World Digitized database.   The  number  of 
  300.     points  and  the  difficulty  of interpreting them outside of a 
  301.     graphics context makes correcting these errors by hand  tedious 
  302.     and error prone.  Any programs which can be developed to locate 
  303.     and correct  errors  automatically  are  valuable  and  inately 
  304.     fulfulling.  Here's your chance to be fulfilled.
  305.     
  306.     1.    Closure  on many closed bodies such as islands and lakes is not 
  307.      complete.  The database consists of  strings  of  co-ordinates 
  308.      separated  by blank lines.  The first point of the next string 
  309.      may be either a continuation of the same body or the start  of 
  310.      a  new  one.   Write  a  program  which  traverses  .mp1 files 
  311.      outputing each record to an output file.  When a new string is 
  312.      found,  determine  whether the new string is a continuation of 
  313.      the old one (is sufficiently close to the last  point  of  the 
  314.      old  string)  or  is  the  start  of  a  new  body. If it is a 
  315.      continuation of the same body, the blank record should be left 
  316.      out.   If  it  is  the start of a new body, an additional or a 
  317.      replacement last record should be inserted in the output  file 
  318.      which  matches  the  first point of the old body thus assuring 
  319.      closure.  There is a strong possibility that the  relation  of 
  320.      the strings and points is indeterminate automatically.
  321.  
  322.     2.    Two  more  problems affecting the reasonableness of the data in 
  323.      the database are lines which cross themselves and angles which 
  324.      are  unnaturally  acute.   Perhaps  both these problems can be 
  325.      addressed by solving the acute angle problem.  Write a program 
  326.      which,  as in case 1 above, reads a .mp1 file and outputs good 
  327.      records to another .mp1  file.   Discard  any  point  n  which 
  328.      causes vectors drawn from n-2 to n-1 and from n-1 to n to form 
  329.      an angle of less than 45 degrees.
  330.     
  331.     While  this  approach  probably  will   solve   many   problems 
  332.     automatically,  it  is not a fool-proof solution.  First of all 
  333.     the results, the points discarded, are dependent on  the  order 
  334.     of  traversing the database.  Is there any way of avoiding this 
  335.     problem?  Secondly and perhaps more obvious  to  you,  throwing 
  336.     out point n associated with an acute angle may leave us with an 
  337.     equally bad n+1 point and angle.  In the  case  of  very  small 
  338.     islands,  the  whole island may disappear, which may not be all 
  339.     bad.  But you could conceive of whole spits or heads of islands 
  340.     being radically changed.
  341.  
  342.     Perhaps  the best solution to problems of the types outlined in 
  343.     cases 1 and 2 is to try  to  combine  automatic  scanning  with 
  344.     graphical display and human decision making at difficult points.
  345.  
  346.  
  347. XII.  Mathematical Analysis of the Data:
  348.     Several  interesting  programs can be written which investigate 
  349.     the relationship of the World Digitized  co-ordinates  to  each 
  350.     other from a purely mathematical perspective.
  351.     
  352.     1.    Write  the  function "spheremi(lat0, long0, lat1, long1)" which 
  353.      returns the distance in statute  miles  separating  two  close 
  354.      places  on the earth.  For the sake of simplicity and speed of 
  355.      execution, you should assume that the chord  approximates  the 
  356.      arc  of  a  swept  angle  for  small  angles  or  sin(theta) = 
  357.      tan(theta) = theta (in radians) for small theta's.  The circle 
  358.      we  are  talking  about, of course, is the great circle of the 
  359.      earth.  The earth's radius is 3959 miles. Remember that  while 
  360.      distance  is linearly related to degrees of latitude, distance 
  361.      is not linearly related to degrees of longitude but depends on 
  362.      the latitude.
  363.  
  364.     2.    Using  the  function "spheremi()", write a program to calculate 
  365.      the total length of the coastlines of the world.
  366.  
  367.     3.    Write a program which prints a histogram  or  a  curve  of  the 
  368.      distribution  of  the  lengths  of  the  vectors making up the 
  369.      coastlands of the world.  One would expect the distribution to 
  370.      be  "normal",  or  perhaps the log of the distribution because 
  371.      the lower bound is 0 while the upper  is  infinite.   Can  you 
  372.      explain  why  it  is not normal?  Is the average vector length 
  373.      different for high latitude sections of  the  database  versus 
  374.      equitorial regions?
  375.  
  376.     4.    Write  a  program  to  calculate  the  area of enclosed figures 
  377.      (islands). I'm not acquainted  with  the  mathematical  theory 
  378.      needed  to  solve  this  problem,  but  I  bet  its simple and 
  379.      powerful.  The storage require-  ments  of  the  program  will 
  380.      probably  also  increase  at least linearly with the number of 
  381.      vectors making up the figure  to  be  evaluated  making  exact 
  382.      calculations  of  larger  areas  (continents)  difficult.  Use 
  383.      related algorithms to calculate the center of mass, moments of 
  384.      inertia, etc.
  385.  
  386.  
  387. XIII.  Program to Insert a B-spline:
  388.     As  you  zoom in closer and closer in your display of The World 
  389.     Digitized, the disjointed nature of the  data  begins  to  look 
  390.     very unnatural.  Running a B-spline between points would insure 
  391.     that the slope of the curve at all points is continuous  adding 
  392.     to the realism.
  393.     
  394.     1.    Write  a  variation  of  the Simple Display Program which would 
  395.      calculate and display a cyclic  cubic  spline  for  a  limited 
  396.      number  of points in the display area when zoomed up enough to 
  397.      make the discontinuous nature of the data obvious.
  398.  
  399.     2.    Devise a method to store the parameters  of  the  spline  in  a 
  400.      binary file ahead of time to reduce the run time calculations.
  401.     
  402.     The  mathematics  of  b-splines  are  beyond the scope of these 
  403.     programming suggestions to cover.   Rogers  and  Adams  in  the 
  404.     Mathematical  Elements for Computer Graphics, McGraw-Hill, 1976 
  405.     discuss cyclic cubic splines.  See page 129 for pictures.
  406.  
  407.  
  408. XIV.  Program to Add More Resolution:
  409.     There is only so much information that is carried  in  a  given 
  410.     drawing  or  database.   The measure of that information is the 
  411.     number of points defining the vectors.  You might suppose  that 
  412.     it  is  impossible  to  add  information  which  is not already 
  413.     explicitly there.  Using the b-spline techniques  suggested  in 
  414.     the last program, it is possible to generate more data based on 
  415.     the implied relationship of the points to each other.
  416.     
  417.     1.    Build a program which reads in a series of points, constructs a 
  418.      spline along those points, and finally approximates the spline 
  419.      with a new set of points at twenty times the  density  of  the 
  420.      original defining points.
  421.  
  422.  
  423. XV.  Program to Reduce Resolution:
  424.     There  are  cases  in which the detail of the database might be 
  425.     too much for the application.  This  overkill  would  not  only 
  426.     slow  the display repaint down unnecessarily, but would consume 
  427.     extra disk space.
  428.     
  429.     1.    Develop an algorithm to cull unneeded points  from  a  database 
  430.      (.mp1 format) outputing the new shorter file.  The trick is to 
  431.      dispose of "extra"  points  without  deforming  the  coastland 
  432.      being  reduced.   The  simplest  approach  would  be to skip 9 
  433.      points out of every 10 if you wanted an output with one  tenth 
  434.      the resolution.  That might work tolerably if you were sure of 
  435.      a uniform distribution of points  to  begin  with.   A  better 
  436.      solution   is  to  use  the  "spheremi()"  function  developed 
  437.      previously to skip  those  points  closer  together  than  the 
  438.      resolution  you require.  The algorithm is to accept the first 
  439.      point and to look for the next point that  falls  outside  the 
  440.      radius  of minimum resolution from the first point.  Write out 
  441.      this accepted point.  It now becomes your new first point.
  442.  
  443.     2.    There may be  cases  in  which  the  points  are  separated  by 
  444.      distances  greater  than the minimum resolution but which fall 
  445.      almost in a straight line.  Define a  minimum  channel  width. 
  446.      Points falling within this channel can be replaced by a single 
  447.      straight line from the first point in the channel to the  last 
  448.      point  in  the  channel.   This  algorithm  is  a  little more 
  449.      challenging and a little more compute intensive.   It  assumes 
  450.      that  the  points have passed the minimum radius test outlined 
  451.      above.  Starting with  the  second  point  beyond  the  anchor 
  452.      point,  imagine a line back to the anchor point.  If the first 
  453.      point beyond the anchor point is within  the  channel  width's 
  454.      distance  to that line, it may be discarded.  Advance to point 
  455.      3 and check points 2 AND point 1  again.   The  process  stops 
  456.      when a point n is chosen such that one of the points 1 through 
  457.      n-1 falls outside the channel.  Point n-1 is retained.
  458.     
  459.     You can see the need for checking back through all  the  points 
  460.     to  the  anchor  each time if you consider what would happen if 
  461.     you tried to reduce a coastland whose points all  gently  arced 
  462.     around  in  a complete circle.  Adjacent points would always be 
  463.     within the channel while the overall shape is obviously  not  a 
  464.     straight  line!   You can also appreciate the non-linear aspect 
  465.     of the number of calculations required as you walk back further 
  466.     and further to discard more and more points.
  467.  
  468.     I  am  not  convinced  that  these  two  approaches to database 
  469.     pruning outlined above will always yield satisfactory  results.  
  470.     Grotesque  spurs  not  representative  of  the original coastal 
  471.     outline might in some cases  be  generated  (or  rather  left).  
  472.     Play with this problem and see if you can come up with a better 
  473.     solution.
  474.  
  475.  
  476. XVI.  A Program to Generate Pseudo Detail:
  477.     The June 1982 issue of the Communications of the  ACM  contains 
  478.     the  article "Computer Rendering of Stochastic Models" authored 
  479.     by three individuals, one from Lucasfilm.  The  abstract  reads 
  480.     in  part  "A recurrent problem in generating realistic pictures 
  481.     by computers is to  represent  natural  irregular  objects  and 
  482.     phenomena  without  undue  time  or  space overhead.... A major 
  483.     advantage of this technique is that it allows us to compute the 
  484.     surface  to  arbitrary levels of details without increasing the 
  485.     database.   Thus  objects  with  complex  appearances  can   be 
  486.     displayed  from  a  very  small database." The authors go on to 
  487.     give example code in Pascal (page 376) and generate  a  map  of 
  488.     Australia from only eight points!
  489.     
  490.     1.    Obtain  the article and implement a two dimensional version for 
  491.      use based on data from The World Digitized.
  492.  
  493.  
  494. XVII.  A Program to Edit Graphics:
  495.     Programmers have written more text editors than you can shake a 
  496.     stick  at.   A  GOOD  graphics  editor  for .mp1 files would be 
  497.     unique and useful (The World Digitized containing assorted, and 
  498.     we  might  add,  minor errors).  Without a graphics editor, the 
  499.     process of relating mistakes from the graphics display  program 
  500.     back  to the .mp1 source file is difficult and error prone.  In 
  501.     addition the changed .mp1 file must be translated into its .mp2 
  502.     version before redisplay and confirmation.
  503.     
  504.     1.    Write  a  graphics editor for .mp1 files.  To keep the response 
  505.      snappy, it should not display the whole or large sections of a 
  506.      database  file  unless  asked to do so.  One should be able to 
  507.      ask for a latitude and longitude at which point  the  graphics 
  508.      editor  scans  the  .mp1  text  file  looking  points  in that 
  509.      location's vicinity. N points (10 to  100,  a  setable  value) 
  510.      should  be  displayed.   The program must calculate the proper 
  511.      world  co-ordinates  based  on  the  points  chosen  for  this 
  512.      display.   The exact point requested should be marked.  Points 
  513.      themselves should be marked with small circles and linked with 
  514.      straight lines.  The editor should allow points to be deleted, 
  515.      moved,  or  added  using  keypad  control  for  selection  and 
  516.      positioning.   Multiple scans forward and backward through the 
  517.      database should be allowed.
  518.     
  519.     The problems of writing good  programs  fall  into  two  parts: 
  520.     writing   a   good   design   specification  and  choosing  the 
  521.     appropriate algorithm  for  implementation.   This  project  is 
  522.     challenging  on  both  counts.  Writing a design spec must be a 
  523.     little like writing a murder mystery. You sit down, close  your 
  524.     eyes,  and ask what your user really wants to do.  You dream up 
  525.     the smallest number of commands which will  enable  him  to  do 
  526.     this  function  well.   You  mull  them over in your mind.  The 
  527.     commands are your mystery  characters.   You  want  to  develop 
  528.     their  personalities  fully.   Are  the commands coherent?  Can 
  529.     they be simpler in syntax yet more  powerful,  ie.  open-ended, 
  530.     all  encompassing,  or  open to ways of use not forseen by you, 
  531.     the author.  Of course there is a limit to what conjecture  can 
  532.     accomplish.   You  must write the syntax of your user interface 
  533.     (language) down and program it.  If the application is  obvious 
  534.     or  if  you're  experienced, your first pass attempt may be the 
  535.     final version.  More often, however, we learn  from  exercising 
  536.     this  prototype.   That's  why  there  are  so many version 2.0 
  537.     programs floating around!
  538.  
  539.     The graphics editor program may have (depending on  your  final 
  540.     design) commands such as:
  541.  
  542.             FIND latitude longitude
  543.             SEARCH FORWARD
  544.             SEARCH BACKWARD
  545.             SEARCH ALL
  546.             SEARCH ONE
  547.             SET DISPLAY n
  548.             DELETE
  549.             MOVE
  550.             ADD
  551.             UNDO LAST
  552.             UNDO ALL DISPLAYED
  553.             DISPLAY ORIGINAL
  554.             DISPLAY NOORIGINAL
  555.             MEASURE DISTANCE
  556.             MEASURE LENGTH
  557.             EXIT
  558.             QUIT
  559.  
  560.     You   have  the  choice  of  implementing  your  grammar  in  a 
  561.     type-it-in interface if you're from the  I-like-to-type  school 
  562.     or  as  a  series  of  menus  if you're from the button-pushing 
  563.     school.  Unless you're very experienced, either interface is  a 
  564.     small  project in and of itself in the graphics display context 
  565.     where you usually  must  solicit  and  display  each  character 
  566.     yourself  while  handling  the  delete,  backspace, and newline 
  567.     functions normally taken care of by the terminal driver. 
  568.  
  569.     Just as important as what the graphics editor is going to do is 
  570.     how it is going to do it.  Issues of simplicity and performance 
  571.     loom before us.  Text editors usually manipulate  an  in-memory 
  572.     linked  list  of  lines.   Large  files complicate the issue by 
  573.     forcing portions of this linked list to be written to  disk  as 
  574.     internal  buffers  are filled.  Functions such as the unlimited 
  575.     backward  scan   of   text   may   be   inhibited   or   become 
  576.     programmatically complex.
  577.  
  578.     This  graphics  editor  is different from a text editor in that 
  579.     while it most assuredly does handle large text files,  most  of 
  580.     the  changes  to be made are minor in comparison to the bulk of 
  581.     data which is already in place.  Therefore a  simpler  strategy 
  582.     for  recording  changes,  additions, and deletions is in order.  
  583.     One method is for the editor to keep track of the line  numbers 
  584.     of  the displayed points. When changes, additions, or deletions 
  585.     are made, records of these transactions along with the  related 
  586.     source  code line numbers are stored in an in-memory structure.  
  587.     The structure may have either linked  records,  be  indexed  in 
  588.     some  fashion,  or  be  sequentially  scanned  for access.  The 
  589.     details and trade offs of the strategy are  best  left  to  the 
  590.     implementor.   In  any event, after a change has been made to a 
  591.     section of the display and that section is left and returned to 
  592.     or searched for later, the new version must be displayed rather 
  593.     than the original version (except upon  request).  A  new  .mp1 
  594.     file  must  be  created  at  editor  exit  time  by copying the 
  595.     original to the new with the  appropriate  changes  folded  in.  
  596.     The original .mp1 file should be renamed with a .bak extension.
  597.  
  598.  
  599. XVIII.  A Program to View the World Digitized as a Globe:
  600.     Until  this point we have been using The World Digitized in two 
  601.     dimensional applications.  Although perphaps not  obvious,  The 
  602.     World  Digitized  is  inherently a 3 dimensional database.  The 
  603.     co-ordinates of latitude and  longitude  are  mappings  from  a 
  604.     sphere, a three dimensional solid.
  605.     
  606.     1.    Create  a  function  which will translate co-ordinates given in 
  607.      latitude/longitude  to  Cartesian  co-ordinates.   The   input 
  608.      arguments  are  latitude,  longitude,  and  altitude above the 
  609.      surface of the earth, and the output arguments x,  y,  and  z.  
  610.      Define  the x-y plane to lie in the plane defined by the great 
  611.      circle of the equator with the positive x  axis  running  from 
  612.      the  center  of  the  earth  (the  origin)  through  the Prime 
  613.      Meridian (longitude  =  0).   In  keeping  with  right  handed 
  614.      conventions,  the positive z axis runs from the earth's center 
  615.      through the Georgraphic North Pole.
  616.  
  617.     2.    Use the function created in step 1 to display .mp2 files  in  3 
  618.      space.  The details of the three-dimensional matrix transforms 
  619.      and  projections  are  beyond  the  scope  of  this  tutorial.  
  620.      Rogers'  and  Adams' book mentioned above treat these subjects 
  621.      thoroughly. A few general observations are in order,  however.  
  622.      You  will  have  to  choose a view point for your perspective, 
  623.      beyond the surface of the earth to begin with.  The view point 
  624.      for  your  projection  can  be  at  infinity or at some finite 
  625.      distance.  You may want to  choose  your  initial  view  point 
  626.      along the x axis (y = z = 0).
  627.     
  628.     Objects on the far side of the earth will be visible unless you 
  629.     clip them.  One solution is to clip everything beyond  a  plane 
  630.     passing  through  the center of the earth and lying parallel to 
  631.     the plane of the display.  This is known as z-clipping although 
  632.     if  your  view  point  lies  on the positive x axis it would be 
  633.     literally -x axis clipping.
  634.  
  635.     Objects which lie toward the limb of the earth will  be  viewed 
  636.     almost  edge  on.   You  may have noticed that the horizon from 
  637.     satellite pictures is indistinct.  That phenomenon may be  due, 
  638.     in part, to the additional haze of the earth atmosphere, but at 
  639.     best those objects would be  hard  to  distinguish  because  of 
  640.     perspective.   You may wish to clip objects not only on the far 
  641.     side of the earth, but those just on this side of the horizon.
  642.  
  643.  
  644.  
  645. XIX.  A Program to Address the Speed/Detail Dilemma:
  646.     One of the most difficult problems facing  graphic  application 
  647.     developers  is  speed.   If  you haven't noticed, you soon will 
  648.     that even a simple application such  as  displaying  The  World 
  649.     Digitized consumes appriciable time.  People expect response in 
  650.     seconds. More than 3 to 5 seconds can be a long wait  for  some 
  651.     applications.  The  simple  display program developed above can 
  652.     display at a rate approaching 200 vectors/second on  a  vanilla 
  653.     IBM PC with math chip (not sure it's being used).  That implies 
  654.     that the full  The  World  Digitized  database,  some  100,000+ 
  655.     co-ordinates,  would  take  on  the  order  of  ten  minutes to 
  656.     display!  Fortunately the detail of the entire database is  not 
  657.     needed when the full breadth of the database is presented.  The 
  658.     problem, then, becomes one of dynamically  trading  off  detail 
  659.     for speed depending on need.
  660.     
  661.     1.    Design a display module for the simple display program outlined 
  662.      above which will minimize  display  time  by  using  only  the 
  663.      detail  necessary  for the current zoom factor.  I am aware of 
  664.      no practical solution to this  most  practical  problem.   The 
  665.      solution  which  first  jumps  to  mind  is using some form of 
  666.      indexing, first of all to limit the range of file scanning for 
  667.      high  zooms,  and  secondly  to skip the detail unnecessary in 
  668.      large area displays. The problems implicit in  this  solution, 
  669.      however,  jump  to  mind  almost as fast.  Different levels of 
  670.      indexing would be  required  by  differing  zoom  factors.   A 
  671.      simple  file  organization  into which to index isn't obvious.  
  672.      The twin problems of data scope and detail remain.  One  trick 
  673.      which may be helpful, however, is to paint the central portion 
  674.      of any given display first.  While the user is  studying  what 
  675.      probably  interests  him most, the program can go on to finish 
  676.      the details around  the  edges  or  informationally  ambiguous 
  677.      areas.   (If  any of you have a good solution, drop me a line.  
  678.      I may not be able to reply, but I  certainly  stand  ready  to 
  679.      learn.)
  680.